home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / dev / lang / python_src.lha / amigapython / objects / classobject.c < prev    next >
C/C++ Source or Header  |  1995-10-22  |  29KB  |  1,309 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Class object implementation */
  26.  
  27. #include "allobjects.h"
  28. #include "structmember.h"
  29.  
  30. /* Forward */
  31. static object *class_lookup PROTO((classobject *, char *, classobject **));
  32. static object *instance_getattr1 PROTO((instanceobject *, char *));
  33.  
  34. object *
  35. newclassobject(bases, dict, name)
  36.     object *bases; /* NULL or tuple of classobjects! */
  37.     object *dict;
  38.     object *name; /* String; NULL if unknown */
  39. {
  40.     int pos;
  41.     object *key, *value;
  42.     classobject *op, *dummy;
  43.     if (dictlookup(dict, "__doc__") == NULL) {
  44.         if (dictinsert(dict, "__doc__", None) < 0)
  45.             return NULL;
  46.     }
  47.     if (bases == NULL) {
  48.         bases = newtupleobject(0);
  49.         if (bases == NULL)
  50.             return NULL;
  51.     }
  52.     else
  53.         INCREF(bases);
  54.     op = NEWOBJ(classobject, &Classtype);
  55.     if (op == NULL) {
  56.         DECREF(bases);
  57.         return NULL;
  58.     }
  59.     op->cl_bases = bases;
  60.     INCREF(dict);
  61.     op->cl_dict = dict;
  62.     XINCREF(name);
  63.     op->cl_name = name;
  64.     op->cl_getattr = class_lookup(op, "__getattr__", &dummy);
  65.     op->cl_setattr = class_lookup(op, "__setattr__", &dummy);
  66.     op->cl_delattr = class_lookup(op, "__delattr__", &dummy);
  67.     XINCREF(op->cl_getattr);
  68.     XINCREF(op->cl_setattr);
  69.     XINCREF(op->cl_delattr);
  70.     pos = 0;
  71.     while (mappinggetnext(dict, &pos, &key, &value)) {
  72.         if (is_accessobject(value))
  73.             setaccessowner(value, (object *)op);
  74.     }
  75.     return (object *) op;
  76. }
  77.  
  78. /* Class methods */
  79.  
  80. static void
  81. class_dealloc(op)
  82.     classobject *op;
  83. {
  84.     DECREF(op->cl_bases);
  85.     DECREF(op->cl_dict);
  86.     XDECREF(op->cl_name);
  87.     free((ANY *)op);
  88. }
  89.  
  90. static object *
  91. class_lookup(cp, name, pclass)
  92.     classobject *cp;
  93.     char *name;
  94.     classobject **pclass;
  95. {
  96.     int i, n;
  97.     object *value = dictlookup(cp->cl_dict, name);
  98.     if (value != NULL) {
  99.         *pclass = cp;
  100.         return value;
  101.     }
  102.     n = gettuplesize(cp->cl_bases);
  103.     for (i = 0; i < n; i++) {
  104.         object *v = class_lookup((classobject *)
  105.                  gettupleitem(cp->cl_bases, i), name, pclass);
  106.         if (v != NULL)
  107.             return v;
  108.     }
  109.     return NULL;
  110. }
  111.  
  112. static object *
  113. class_getattr(op, name)
  114.     register classobject *op;
  115.     register char *name;
  116. {
  117.     register object *v;
  118.     classobject *class;
  119.     if (name[0] == '_' && name[1] == '_') {
  120.         if (strcmp(name, "__dict__") == 0) {
  121.             if (getrestricted()) {
  122.                 err_setstr(RuntimeError,
  123.                        "class.__dict__ not accessible in restricted mode");
  124.                 return NULL;
  125.             }
  126.             INCREF(op->cl_dict);
  127.             return op->cl_dict;
  128.         }
  129.         if (strcmp(name, "__bases__") == 0) {
  130.             INCREF(op->cl_bases);
  131.             return op->cl_bases;
  132.         }
  133.         if (strcmp(name, "__name__") == 0) {
  134.             if (op->cl_name == NULL)
  135.                 v = None;
  136.             else
  137.                 v = op->cl_name;
  138.             INCREF(v);
  139.             return v;
  140.         }
  141.     }
  142.     v = class_lookup(op, name, &class);
  143.     if (v == NULL) {
  144.         err_setstr(AttributeError, name);
  145.         return NULL;
  146.     }
  147.     if (is_accessobject(v)) {
  148.         v = getaccessvalue(v, getowner());
  149.         if (v == NULL)
  150.             return NULL;
  151.     }
  152.     else
  153.         INCREF(v);
  154.     if (is_funcobject(v)) {
  155.         object *w = newinstancemethodobject(v, (object *)NULL,
  156.                             (object *)class);
  157.         DECREF(v);
  158.         v = w;
  159.     }
  160.     return v;
  161. }
  162.  
  163. static int
  164. class_setattr(op, name, v)
  165.     classobject *op;
  166.     char *name;
  167.     object *v;
  168. {
  169.     object *ac;
  170.     if (name[0] == '_' && name[1] == '_') {
  171.         int n = strlen(name);
  172.         if (name[n-1] == '_' && name[n-2] == '_') {
  173.             err_setstr(TypeError, "read-only special attribute");
  174.             return -1;
  175.         }
  176.     }
  177.     if (getrestricted()) {
  178.         err_setstr(RuntimeError,
  179.                "classes are read-only in restricted mode");
  180.         return -1;
  181.     }
  182.     ac = dictlookup(op->cl_dict, name);
  183.     if (ac != NULL && is_accessobject(ac))
  184.         return setaccessvalue(ac, getowner(), v);
  185.     if (v == NULL) {
  186.         int rv = dictremove(op->cl_dict, name);
  187.         if (rv < 0)
  188.             err_setstr(AttributeError,
  189.                    "delete non-existing class attribute");
  190.         return rv;
  191.     }
  192.     else
  193.         return dictinsert(op->cl_dict, name, v);
  194. }
  195.  
  196. static object *
  197. class_repr(op)
  198.     classobject *op;
  199. {
  200.     char buf[140];
  201.     char *name;
  202.     if (op->cl_name == NULL || !is_stringobject(op->cl_name))
  203.         name = "?";
  204.     else
  205.         name = getstringvalue(op->cl_name);
  206.     sprintf(buf, "<class %.100s at %lx>", name, (long)op);
  207.     return newstringobject(buf);
  208. }
  209.  
  210. typeobject Classtype = {
  211.     OB_HEAD_INIT(&Typetype)
  212.     0,
  213.     "class",
  214.     sizeof(classobject),
  215.     0,
  216.     (destructor)class_dealloc, /*tp_dealloc*/
  217.     0,        /*tp_print*/
  218.     (getattrfunc)class_getattr, /*tp_getattr*/
  219.     (setattrfunc)class_setattr, /*tp_setattr*/
  220.     0,        /*tp_compare*/
  221.     (reprfunc)class_repr, /*tp_repr*/
  222.     0,        /*tp_as_number*/
  223.     0,        /*tp_as_sequence*/
  224.     0,        /*tp_as_mapping*/
  225. };
  226.  
  227. int
  228. issubclass(class, base)
  229.     object *class;
  230.     object *base;
  231. {
  232.     int i, n;
  233.     classobject *cp;
  234.     if (class == base)
  235.         return 1;
  236.     if (class == NULL || !is_classobject(class))
  237.         return 0;
  238.     cp = (classobject *)class;
  239.     n = gettuplesize(cp->cl_bases);
  240.     for (i = 0; i < n; i++) {
  241.         if (issubclass(gettupleitem(cp->cl_bases, i), base))
  242.             return 1;
  243.     }
  244.     return 0;
  245. }
  246.  
  247.  
  248. /* Instance objects */
  249.  
  250. static int
  251. addaccess(class, inst)
  252.     classobject *class;
  253.     instanceobject *inst;
  254. {
  255.     int i, n, pos, ret;
  256.     object *key, *value, *ac;
  257.     
  258.     n = gettuplesize(class->cl_bases);
  259.     for (i = 0; i < n; i++) {
  260.         if (addaccess((classobject *)gettupleitem(class->cl_bases, i), inst) < 0)
  261.             return -1;
  262.     }
  263.     
  264.     pos = 0;
  265.     while (mappinggetnext(class->cl_dict, &pos, &key, &value)) {
  266.         if (!is_accessobject(value))
  267.             continue;
  268.         if (hasaccessvalue(value))
  269.             continue;
  270.         ac = dict2lookup(inst->in_dict, key);
  271.         if (ac != NULL && is_accessobject(ac)) {
  272.             err_setval(ConflictError, key);
  273.             return -1;
  274.         }
  275.         ac = cloneaccessobject(value);
  276.         if (ac == NULL)
  277.             return -1;
  278.         ret = dict2insert(inst->in_dict, key, ac);
  279.         DECREF(ac);
  280.         if (ret != 0)
  281.             return -1;
  282.         }
  283.     return 0;
  284. }
  285.  
  286. object *
  287. newinstanceobject(class, arg, kw)
  288.     object *class;
  289.     object *arg;
  290.     object *kw;
  291. {
  292.     register instanceobject *inst;
  293.     object *init;
  294.     if (!is_classobject(class)) {
  295.         err_badcall();
  296.         return NULL;
  297.     }
  298.     inst = NEWOBJ(instanceobject, &Instancetype);
  299.     if (inst == NULL)
  300.         return NULL;
  301.     INCREF(class);
  302.     inst->in_class = (classobject *)class;
  303.     inst->in_dict = newdictobject();
  304.     if (inst->in_dict == NULL ||
  305.         addaccess((classobject *)class, inst) != 0) {
  306.         DECREF(inst);
  307.         return NULL;
  308.     }
  309.     init = instance_getattr1(inst, "__init__");
  310.     if (init == NULL) {
  311.         err_clear();
  312.         if (arg != NULL && (!is_tupleobject(arg) ||
  313.                     gettuplesize(arg) != 0) || kw != NULL) {
  314.             err_setstr(TypeError,
  315.                    "this constructor takes no arguments");
  316.             DECREF(inst);
  317.             inst = NULL;
  318.         }
  319.     }
  320.     else {
  321.         object *res = PyEval_CallObjectWithKeywords(init, arg, kw);
  322.         DECREF(init);
  323.         if (res == NULL) {
  324.             DECREF(inst);
  325.             inst = NULL;
  326.         }
  327.         else {
  328.             if (res != None) {
  329.                 err_setstr(TypeError,
  330.                        "__init__() should return None");
  331.                 DECREF(inst);
  332.                 inst = NULL;
  333.             }
  334.             DECREF(res);
  335.         }
  336.     }
  337.     return (object *)inst;
  338. }
  339.  
  340. /* Instance methods */
  341.  
  342. static void
  343. instance_dealloc(inst)
  344.     register instanceobject *inst;
  345. {
  346.     object *error_type, *error_value, *error_traceback;
  347.     object *del;
  348.     /* Call the __del__ method if it exists.  First temporarily
  349.        revive the object and save the current exception, if any. */
  350. #ifdef TRACE_REFS
  351.     /* much too complicated if TRACE_REFS defined */
  352.     extern long ref_total;
  353.     inst->ob_type = &Instancetype;
  354.     NEWREF(inst);
  355.     ref_total--;        /* compensate for increment in NEWREF */
  356. #ifdef COUNT_ALLOCS
  357.     inst->ob_type->tp_alloc--; /* ditto */
  358. #endif
  359. #else
  360.     INCREF(inst);
  361. #endif /* TRACE_REFS */
  362.     err_fetch(&error_type, &error_value, &error_traceback);
  363.     if ((del = instance_getattr1(inst, "__del__")) != NULL) {
  364.         object *res = call_object(del, (object *)NULL);
  365.         DECREF(del);
  366.         XDECREF(res);
  367.         /* XXX If __del__ raised an exception, it is ignored! */
  368.     }
  369.     /* Restore the saved exception and undo the temporary revival */
  370.     err_restore(error_type, error_value, error_traceback);
  371.     /* Can't use DECREF here, it would cause a recursive call */
  372.     if (--inst->ob_refcnt > 0) {
  373. #ifdef COUNT_ALLOCS
  374.         inst->ob_type->tp_free--;
  375. #endif
  376.         return; /* __del__ added a reference; don't delete now */
  377.     }
  378. #ifdef TRACE_REFS
  379. #ifdef COUNT_ALLOCS
  380.     inst->ob_type->tp_free--;    /* compensate for increment in UNREF */
  381. #endif
  382.     UNREF(inst);
  383.     inst->ob_type = NULL;
  384. #endif /* TRACE_REFS */
  385.     DECREF(inst->in_class);
  386.     XDECREF(inst->in_dict);
  387.     free((ANY *)inst);
  388. }
  389.  
  390. static object *
  391. instance_getattr1(inst, name)
  392.     register instanceobject *inst;
  393.     register char *name;
  394. {
  395.     register object *v;
  396.     classobject *class;
  397.     if (name[0] == '_' && name[1] == '_') {
  398.         if (strcmp(name, "__dict__") == 0) {
  399.             if (getrestricted()) {
  400.                 err_setstr(RuntimeError,
  401.                        "instance.__dict__ not accessible in restricted mode");
  402.                 return NULL;
  403.             }
  404.             INCREF(inst->in_dict);
  405.             return inst->in_dict;
  406.         }
  407.         if (strcmp(name, "__class__") == 0) {
  408.             INCREF(inst->in_class);
  409.             return (object *)inst->in_class;
  410.         }
  411.     }
  412.     class = NULL;
  413.     v = dictlookup(inst->in_dict, name);
  414.     if (v == NULL) {
  415.         v = class_lookup(inst->in_class, name, &class);
  416.         if (v == NULL) {
  417.             err_setstr(AttributeError, name);
  418.             return NULL;
  419.         }
  420.     }
  421.     if (is_accessobject(v)) {
  422.         v = getaccessvalue(v, getowner());
  423.         if (v == NULL)
  424.             return NULL;
  425.     }
  426.     else
  427.         INCREF(v);
  428.     if (class != NULL) {
  429.         if (is_funcobject(v)) {
  430.             object *w = newinstancemethodobject(v, (object *)inst,
  431.                                 (object *)class);
  432.             DECREF(v);
  433.             v = w;
  434.         }
  435.         else if (is_instancemethodobject(v)) {
  436.             object *im_class = instancemethodgetclass(v);
  437.             /* Only if classes are compatible */
  438.             if (issubclass((object *)class, im_class)) {
  439.                 object *im_func = instancemethodgetfunc(v);
  440.                 object *w = newinstancemethodobject(im_func,
  441.                         (object *)inst, im_class);
  442.                 DECREF(v);
  443.                 v = w;
  444.             }
  445.         }
  446.     }
  447.     return v;
  448. }
  449.  
  450. static object *
  451. instance_getattr(inst, name)
  452.     register instanceobject *inst;
  453.     register char *name;
  454. {
  455.     register object *func, *res;
  456.     res = instance_getattr1(inst, name);
  457.     if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
  458.         object *args;
  459.         err_clear();
  460.         args = mkvalue("(Os)", inst, name);
  461.         if (args == NULL)
  462.             return NULL;
  463.         res = call_object(func, args);
  464.         DECREF(args);
  465.     }
  466.     return res;
  467. }
  468.  
  469. static int
  470. instance_setattr1(inst, name, v)
  471.     instanceobject *inst;
  472.     char *name;
  473.     object *v;
  474. {
  475.     object *ac;
  476.     ac = dictlookup(inst->in_dict, name);
  477.     if (ac != NULL && is_accessobject(ac))
  478.         return setaccessvalue(ac, getowner(), v);
  479.     if (v == NULL) {
  480.         int rv = dictremove(inst->in_dict, name);
  481.         if (rv < 0)
  482.             err_setstr(AttributeError,
  483.                    "delete non-existing instance attribute");
  484.         return rv;
  485.     }
  486.     else
  487.         return dictinsert(inst->in_dict, name, v);
  488. }
  489.  
  490. static int
  491. instance_setattr(inst, name, v)
  492.     instanceobject *inst;
  493.     char *name;
  494.     object *v;
  495. {
  496.     object *func, *args, *res;
  497.     if (name[0] == '_' && name[1] == '_') {
  498.         int n = strlen(name);
  499.         if (name[n-1] == '_' && name[n-2] == '_') {
  500.             err_setstr(TypeError, "read-only special attribute");
  501.             return -1;
  502.         }
  503.     }
  504.     if (v == NULL)
  505.         func = inst->in_class->cl_delattr;
  506.     else
  507.         func = inst->in_class->cl_setattr;
  508.     if (func == NULL)
  509.         return instance_setattr1(inst, name, v);
  510.     if (v == NULL)
  511.         args = mkvalue("(Os)", inst, name);
  512.     else
  513.         args = mkvalue("(OsO)", inst, name, v);
  514.     if (args == NULL)
  515.         return -1;
  516.     res = call_object(func, args);
  517.     DECREF(args);
  518.     if (res == NULL)
  519.         return -1;
  520.     DECREF(res);
  521.     return 0;
  522. }
  523.  
  524. static object *
  525. instance_repr(inst)
  526.     instanceobject *inst;
  527. {
  528.     object *func;
  529.     object *res;
  530.  
  531.     func = instance_getattr(inst, "__repr__");
  532.     if (func == NULL) {
  533.         char buf[140];
  534.         object *classname = inst->in_class->cl_name;
  535.         char *cname;
  536.         if (classname != NULL && is_stringobject(classname))
  537.             cname = getstringvalue(classname);
  538.         else
  539.             cname = "?";
  540.         err_clear();
  541.         sprintf(buf, "<%.100s instance at %lx>", cname, (long)inst);
  542.         return newstringobject(buf);
  543.     }
  544.     res = call_object(func, (object *)NULL);
  545.     DECREF(func);
  546.     return res;
  547. }
  548.  
  549. static object *
  550. instance_compare1(inst, other)
  551.     object *inst, *other;
  552. {
  553.     return instancebinop(inst, other, "__cmp__", "__rcmp__",
  554.                  instance_compare1);
  555. }
  556.  
  557. static int
  558. instance_compare(inst, other)
  559.     object *inst, *other;
  560. {
  561.     object *result;
  562.     long outcome;
  563.     result = instance_compare1(inst, other);
  564.     if (result == NULL || !is_intobject(result)) {
  565.     error:
  566.         err_clear();
  567.         return (inst < other) ? -1 : 1;
  568.     }
  569.     outcome = getintvalue(result);
  570.     DECREF(result);
  571.     if (outcome < 0)
  572.         return -1;
  573.     else if (outcome > 0)
  574.         return 1;
  575.     return 0;
  576. }
  577.  
  578. static long
  579. instance_hash(inst)
  580.     instanceobject *inst;
  581. {
  582.     object *func;
  583.     object *res;
  584.     long outcome;
  585.  
  586.     func = instance_getattr(inst, "__hash__");
  587.     if (func == NULL) {
  588.         /* If there is no __cmp__ method, we hash on the address.
  589.            If a __cmp__ method exists, there must be a __hash__. */
  590.         err_clear();
  591.         func = instance_getattr(inst, "__cmp__");
  592.         if (func == NULL) {
  593.             err_clear();
  594.             outcome = (long)inst;
  595.             if (outcome == -1)
  596.                 outcome = -2;
  597.             return outcome;
  598.         }
  599.         err_setstr(TypeError, "unhashable instance");
  600.         return -1;
  601.     }
  602.     res = call_object(func, (object *)NULL);
  603.     DECREF(func);
  604.     if (res == NULL)
  605.         return -1;
  606.     if (is_intobject(res)) {
  607.         outcome = getintvalue(res);
  608.         if (outcome == -1)
  609.             outcome = -2;
  610.     }
  611.     else {
  612.         err_setstr(TypeError, "__hash__() should return an int");
  613.         outcome = -1;
  614.     }
  615.     DECREF(res);
  616.     return outcome;
  617. }
  618.  
  619. static int
  620. instance_length(inst)
  621.     instanceobject *inst;
  622. {
  623.     object *func;
  624.     object *res;
  625.     int outcome;
  626.  
  627.     func = instance_getattr(inst, "__len__");
  628.     if (func == NULL)
  629.         return -1;
  630.     res = call_object(func, (object *)NULL);
  631.     DECREF(func);
  632.     if (res == NULL)
  633.         return -1;
  634.     if (is_intobject(res)) {
  635.         outcome = getintvalue(res);
  636.         if (outcome < 0)
  637.             err_setstr(ValueError, "__len__() should return >= 0");
  638.     }
  639.     else {
  640.         err_setstr(TypeError, "__len__() should return an int");
  641.         outcome = -1;
  642.     }
  643.     DECREF(res);
  644.     return outcome;
  645. }
  646.  
  647. static object *
  648. instance_subscript(inst, key)
  649.     instanceobject *inst;
  650.     object *key;
  651. {
  652.     object *func;
  653.     object *arg;
  654.     object *res;
  655.  
  656.     func = instance_getattr(inst, "__getitem__");
  657.     if (func == NULL)
  658.         return NULL;
  659.     arg = mkvalue("(O)", key);
  660.     if (arg == NULL) {
  661.         DECREF(func);
  662.         return NULL;
  663.     }
  664.     res = call_object(func, arg);
  665.     DECREF(func);
  666.     DECREF(arg);
  667.     return res;
  668. }
  669.  
  670. static int
  671. instance_ass_subscript(inst, key, value)
  672.     instanceobject*inst;
  673.     object *key;
  674.     object *value;
  675. {
  676.     object *func;
  677.     object *arg;
  678.     object *res;
  679.  
  680.     if (value == NULL)
  681.         func = instance_getattr(inst, "__delitem__");
  682.     else
  683.         func = instance_getattr(inst, "__setitem__");
  684.     if (func == NULL)
  685.         return -1;
  686.     if (value == NULL)
  687.         arg = mkvalue("(O)", key);
  688.     else
  689.         arg = mkvalue("(OO)", key, value);
  690.     if (arg == NULL) {
  691.         DECREF(func);
  692.         return -1;
  693.     }
  694.     res = call_object(func, arg);
  695.     DECREF(func);
  696.     DECREF(arg);
  697.     if (res == NULL)
  698.         return -1;
  699.     DECREF(res);
  700.     return 0;
  701. }
  702.  
  703. static mapping_methods instance_as_mapping = {
  704.     (inquiry)instance_length, /*mp_length*/
  705.     (binaryfunc)instance_subscript, /*mp_subscript*/
  706.     (objobjargproc)instance_ass_subscript, /*mp_ass_subscript*/
  707. };
  708.  
  709. static object *
  710. instance_item(inst, i)
  711.     instanceobject *inst;
  712.     int i;
  713. {
  714.     object *func, *arg, *res;
  715.  
  716.     func = instance_getattr(inst, "__getitem__");
  717.     if (func == NULL)
  718.         return NULL;
  719.     arg = mkvalue("(i)", i);
  720.     if (arg == NULL) {
  721.         DECREF(func);
  722.         return NULL;
  723.     }
  724.     res = call_object(func, arg);
  725.     DECREF(func);
  726.     DECREF(arg);
  727.     return res;
  728. }
  729.  
  730. static object *
  731. instance_slice(inst, i, j)
  732.     instanceobject *inst;
  733.     int i, j;
  734. {
  735.     object *func, *arg, *res;
  736.  
  737.     func = instance_getattr(inst, "__getslice__");
  738.     if (func == NULL)
  739.         return NULL;
  740.     arg = mkvalue("(ii)", i, j);
  741.     if (arg == NULL) {
  742.         DECREF(func);
  743.         return NULL;
  744.     }
  745.     res = call_object(func, arg);
  746.     DECREF(func);
  747.     DECREF(arg);
  748.     return res;
  749. }
  750.  
  751. static int
  752. instance_ass_item(inst, i, item)
  753.     instanceobject *inst;
  754.     int i;
  755.     object *item;
  756. {
  757.     object *func, *arg, *res;
  758.  
  759.     if (item == NULL)
  760.         func = instance_getattr(inst, "__delitem__");
  761.     else
  762.         func = instance_getattr(inst, "__setitem__");
  763.     if (func == NULL)
  764.         return -1;
  765.     if (item == NULL)
  766.         arg = mkvalue("i", i);
  767.     else
  768.         arg = mkvalue("(iO)", i, item);
  769.     if (arg == NULL) {
  770.         DECREF(func);
  771.         return -1;
  772.     }
  773.     res = call_object(func, arg);
  774.     DECREF(func);
  775.     DECREF(arg);
  776.     if (res == NULL)
  777.         return -1;
  778.     DECREF(res);
  779.     return 0;
  780. }
  781.  
  782. static int
  783. instance_ass_slice(inst, i, j, value)
  784.     instanceobject *inst;
  785.     int i, j;
  786.     object *value;
  787. {
  788.     object *func, *arg, *res;
  789.  
  790.     if (value == NULL)
  791.         func = instance_getattr(inst, "__delslice__");
  792.     else
  793.         func = instance_getattr(inst, "__setslice__");
  794.     if (func == NULL)
  795.         return -1;
  796.     if (value == NULL)
  797.         arg = mkvalue("(ii)", i, j);
  798.     else
  799.         arg = mkvalue("(iiO)", i, j, value);
  800.     if (arg == NULL) {
  801.         DECREF(func);
  802.         return -1;
  803.     }
  804.     res = call_object(func, arg);
  805.     DECREF(func);
  806.     DECREF(arg);
  807.     if (res == NULL)
  808.         return -1;
  809.     DECREF(res);
  810.     return 0;
  811. }
  812.  
  813. static sequence_methods instance_as_sequence = {
  814.     (inquiry)instance_length, /*sq_length*/
  815.     0, /*sq_concat*/
  816.     0, /*sq_repeat*/
  817.     (intargfunc)instance_item, /*sq_item*/
  818.     (intintargfunc)instance_slice, /*sq_slice*/
  819.     (intobjargproc)instance_ass_item, /*sq_ass_item*/
  820.     (intintobjargproc)instance_ass_slice, /*sq_ass_slice*/
  821. };
  822.  
  823. static object *
  824. generic_unary_op(self, methodname)
  825.     instanceobject *self;
  826.     char *methodname;
  827. {
  828.     object *func, *res;
  829.  
  830.     if ((func = instance_getattr(self, methodname)) == NULL)
  831.         return NULL;
  832.     res = call_object(func, (object *)NULL);
  833.     DECREF(func);
  834.     return res;
  835. }
  836.  
  837.  
  838. /* Forward */
  839. static int halfbinop PROTO((object *, object *, char *, object **,
  840.                 object * (*) PROTO((object *, object *)), int ));
  841.  
  842.  
  843. /* Implement a binary operator involving at least one class instance. */
  844.  
  845. object *
  846. instancebinop(v, w, opname, ropname, thisfunc)
  847.     object *v;
  848.     object *w;
  849.     char *opname;
  850.     char *ropname;
  851.     object * (*thisfunc) PROTO((object *, object *));
  852. {
  853.     char buf[256];
  854.     object *result = NULL;
  855.     if (halfbinop(v, w, opname, &result, thisfunc, 0) <= 0)
  856.         return result;
  857.     if (halfbinop(w, v, ropname, &result, thisfunc, 1) <= 0)
  858.         return result;
  859.     sprintf(buf, "%s nor %s defined for these operands", opname, ropname);
  860.     err_setstr(TypeError, buf);
  861.     return NULL;
  862. }
  863.  
  864.  
  865. /* Try one half of a binary operator involving a class instance.
  866.    Return value:
  867.    -1 if an exception is to be reported right away
  868.    0  if we have a valid result
  869.    1  if we could try another operation
  870. */
  871.  
  872. static int
  873. halfbinop(v, w, opname, r_result, thisfunc, swapped)
  874.     object *v;
  875.     object *w;
  876.     char *opname;
  877.     object **r_result;
  878.     object * (*thisfunc) PROTO((object *, object *));
  879.     int swapped;
  880. {
  881.     object *func;
  882.     object *args;
  883.     object *coerce;
  884.     object *coerced = NULL;
  885.     object *v1;
  886.     
  887.     if (!is_instanceobject(v))
  888.         return 1;
  889.     coerce = getattr(v, "__coerce__");
  890.     if (coerce == NULL) {
  891.         err_clear();
  892.     }
  893.     else {
  894.         args = mkvalue("(O)", w);
  895.         if (args == NULL) {
  896.             return -1;
  897.         }
  898.         coerced = call_object(coerce, args);
  899.         DECREF(args);
  900.         DECREF(coerce);
  901.         if (coerced == NULL) {
  902.             return -1;
  903.         }
  904.         if (coerced == None) {
  905.             DECREF(coerced);
  906.             return 1;
  907.         }
  908.         if (!is_tupleobject(coerced) || gettuplesize(coerced) != 2) {
  909.             DECREF(coerced);
  910.             err_setstr(TypeError,
  911.                    "coercion should return None or 2-tuple");
  912.             return -1;
  913.         }
  914.         v1 = gettupleitem(coerced, 0);
  915.         w = gettupleitem(coerced, 1);
  916.         if (v1 != v) {
  917.             v = v1;
  918.             if (!is_instanceobject(v) && !is_instanceobject(w)) {
  919.                 if (swapped)
  920.                     *r_result = (*thisfunc)(w, v);
  921.                 else
  922.                     *r_result = (*thisfunc)(v, w);
  923.                 DECREF(coerced);
  924.                 return *r_result == NULL ? -1 : 0;
  925.             }
  926.         }
  927.         w = gettupleitem(coerced, 1);
  928.     }
  929.     func = getattr(v, opname);
  930.     if (func == NULL) {
  931.         XDECREF(coerced);
  932.         if (err_occurred() != AttributeError)
  933.             return -1;
  934.         err_clear();
  935.         return 1;
  936.     }
  937.     args = mkvalue("(O)", w);
  938.     if (args == NULL) {
  939.         DECREF(func);
  940.         XDECREF(coerced);
  941.         return -1;
  942.     }
  943.     *r_result = call_object(func, args);
  944.     DECREF(args);
  945.     DECREF(func);
  946.     XDECREF(coerced);
  947.     return *r_result == NULL ? -1 : 0;
  948. }
  949.  
  950. static int
  951. instance_coerce(pv, pw)
  952.     object **pv;
  953.     object **pw;
  954. {
  955.     object *v = *pv;
  956.     object *w = *pw;
  957.     object *coerce;
  958.     object *args;
  959.     object *coerced;
  960.  
  961.     coerce = getattr(v, "__coerce__");
  962.     if (coerce == NULL) {
  963.         /* No __coerce__ method: always OK */
  964.         err_clear();
  965.         INCREF(v);
  966.         INCREF(w);
  967.         return 0;
  968.     }
  969.     /* Has __coerce__ method: call it */
  970.     args = mkvalue("(O)", w);
  971.     if (args == NULL) {
  972.         return -1;
  973.     }
  974.     coerced = call_object(coerce, args);
  975.     DECREF(args);
  976.     DECREF(coerce);
  977.     if (coerced == NULL) {
  978.         /* __coerce__ call raised an exception */
  979.         return -1;
  980.     }
  981.     if (coerced == None) {
  982.         /* __coerce__ says "I can't do it" */
  983.         DECREF(coerced);
  984.         return 1;
  985.     }
  986.     if (!is_tupleobject(coerced) || gettuplesize(coerced) != 2) {
  987.         /* __coerce__ return value is malformed */
  988.         DECREF(coerced);
  989.         err_setstr(TypeError,
  990.                "coercion should return None or 2-tuple");
  991.         return -1;
  992.     }
  993.     /* __coerce__ returned two new values */
  994.     *pv = gettupleitem(coerced, 0);
  995.     *pw = gettupleitem(coerced, 1);
  996.     INCREF(*pv);
  997.     INCREF(*pw);
  998.     DECREF(coerced);
  999.     return 0;
  1000. }
  1001.  
  1002.  
  1003. #define UNARY(funcname, methodname) \
  1004. static object *funcname(self) instanceobject *self; { \
  1005.     return generic_unary_op(self, methodname); \
  1006. }
  1007.  
  1008. UNARY(instance_neg, "__neg__")
  1009. UNARY(instance_pos, "__pos__")
  1010. UNARY(instance_abs, "__abs__")
  1011.  
  1012. static int
  1013. instance_nonzero(self)
  1014.     instanceobject *self;
  1015. {
  1016.     object *func, *res;
  1017.     long outcome;
  1018.  
  1019.     if ((func = instance_getattr(self, "__nonzero__")) == NULL) {
  1020.         err_clear();
  1021.         if ((func = instance_getattr(self, "__len__")) == NULL) {
  1022.             err_clear();
  1023.             /* Fall back to the default behavior:
  1024.                all instances are nonzero */
  1025.             return 1;
  1026.         }
  1027.     }
  1028.     res = call_object(func, (object *)NULL);
  1029.     DECREF(func);
  1030.     if (res == NULL)
  1031.         return -1;
  1032.     if (!is_intobject(res)) {
  1033.         DECREF(res);
  1034.         err_setstr(TypeError, "__nonzero__ should return an int");
  1035.         return -1;
  1036.     }
  1037.     outcome = getintvalue(res);
  1038.     DECREF(res);
  1039.     if (outcome < 0) {
  1040.         err_setstr(ValueError, "__nonzero__ should return >= 0");
  1041.         return -1;
  1042.     }
  1043.     return outcome > 0;
  1044. }
  1045.  
  1046. UNARY(instance_invert, "__invert__")
  1047. UNARY(instance_int, "__int__")
  1048. UNARY(instance_long, "__long__")
  1049. UNARY(instance_float, "__float__")
  1050. UNARY(instance_oct, "__oct__")
  1051. UNARY(instance_hex, "__hex__")
  1052.  
  1053. /* This version is for ternary calls only (z != None) */
  1054. static object *
  1055. instance_pow(v, w, z)
  1056.     object *v;
  1057.     object *w;
  1058.     object *z;
  1059. {
  1060.     /* XXX Doesn't do coercions... */
  1061.     object *func;
  1062.     object *args;
  1063.     object *result;
  1064.     func = getattr(v, "__pow__");
  1065.     if (func == NULL)
  1066.         return NULL;
  1067.     args = mkvalue("(OO)", w, z);
  1068.     if (args == NULL) {
  1069.         DECREF(func);
  1070.         return NULL;
  1071.     }
  1072.     result = call_object(func, args);
  1073.     DECREF(func);
  1074.     DECREF(args);
  1075.     return result;
  1076. }
  1077.  
  1078. static number_methods instance_as_number = {
  1079.     0, /*nb_add*/
  1080.     0, /*nb_subtract*/
  1081.     0, /*nb_multiply*/
  1082.     0, /*nb_divide*/
  1083.     0, /*nb_remainder*/
  1084.     0, /*nb_divmod*/
  1085.     (ternaryfunc)instance_pow, /*nb_power*/
  1086.     (unaryfunc)instance_neg, /*nb_negative*/
  1087.     (unaryfunc)instance_pos, /*nb_positive*/
  1088.     (unaryfunc)instance_abs, /*nb_absolute*/
  1089.     (inquiry)instance_nonzero, /*nb_nonzero*/
  1090.     (unaryfunc)instance_invert, /*nb_invert*/
  1091.     0, /*nb_lshift*/
  1092.     0, /*nb_rshift*/
  1093.     0, /*nb_and*/
  1094.     0, /*nb_xor*/
  1095.     0, /*nb_or*/
  1096.     (coercion)instance_coerce, /*nb_coerce*/
  1097.     (unaryfunc)instance_int, /*nb_int*/
  1098.     (unaryfunc)instance_long, /*nb_long*/
  1099.     (unaryfunc)instance_float, /*nb_float*/
  1100.     (unaryfunc)instance_oct, /*nb_oct*/
  1101.     (unaryfunc)instance_hex, /*nb_hex*/
  1102. };
  1103.  
  1104. typeobject Instancetype = {
  1105.     OB_HEAD_INIT(&Typetype)
  1106.     0,
  1107.     "instance",
  1108.     sizeof(instanceobject),
  1109.     0,
  1110.     (destructor)instance_dealloc, /*tp_dealloc*/
  1111.     0,            /*tp_print*/
  1112.     (getattrfunc)instance_getattr, /*tp_getattr*/
  1113.     (setattrfunc)instance_setattr, /*tp_setattr*/
  1114.     instance_compare, /*tp_compare*/
  1115.     (reprfunc)instance_repr, /*tp_repr*/
  1116.     &instance_as_number,    /*tp_as_number*/
  1117.     &instance_as_sequence,    /*tp_as_sequence*/
  1118.     &instance_as_mapping,    /*tp_as_mapping*/
  1119.     (hashfunc)instance_hash, /*tp_hash*/
  1120. };
  1121.  
  1122.  
  1123. /* Instance method objects are used for two purposes:
  1124.    (a) as bound instance methods (returned by instancename.methodname)
  1125.    (b) as unbound methods (returned by ClassName.methodname)
  1126.    In case (b), im_self is NULL
  1127. */
  1128.  
  1129. typedef struct {
  1130.     OB_HEAD
  1131.     object    *im_func;    /* The function implementing the method */
  1132.     object    *im_self;    /* The instance it is bound to, or NULL */
  1133.     object    *im_class;    /* The class that defined the method */
  1134.     object    *im_doc;    /* The documentation string */
  1135. } instancemethodobject;
  1136.  
  1137. object *
  1138. newinstancemethodobject(func, self, class)
  1139.     object *func;
  1140.     object *self;
  1141.     object *class;
  1142. {
  1143.     register instancemethodobject *im;
  1144.     if (!is_funcobject(func)) {
  1145.         err_badcall();
  1146.         return NULL;
  1147.     }
  1148.     im = NEWOBJ(instancemethodobject, &Instancemethodtype);
  1149.     if (im == NULL)
  1150.         return NULL;
  1151.     INCREF(func);
  1152.     im->im_func = func;
  1153.     XINCREF(self);
  1154.     im->im_self = self;
  1155.     INCREF(class);
  1156.     im->im_class = class;
  1157.     XINCREF(((funcobject *)func)->func_doc);
  1158.     im->im_doc = ((funcobject *)func)->func_doc;
  1159.     return (object *)im;
  1160. }
  1161.  
  1162. object *
  1163. instancemethodgetfunc(im)
  1164.     register object *im;
  1165. {
  1166.     if (!is_instancemethodobject(im)) {
  1167.         err_badcall();
  1168.         return NULL;
  1169.     }
  1170.     return ((instancemethodobject *)im)->im_func;
  1171. }
  1172.  
  1173. object *
  1174. instancemethodgetself(im)
  1175.     register object *im;
  1176. {
  1177.     if (!is_instancemethodobject(im)) {
  1178.         err_badcall();
  1179.         return NULL;
  1180.     }
  1181.     return ((instancemethodobject *)im)->im_self;
  1182. }
  1183.  
  1184. object *
  1185. instancemethodgetclass(im)
  1186.     register object *im;
  1187. {
  1188.     if (!is_instancemethodobject(im)) {
  1189.         err_badcall();
  1190.         return NULL;
  1191.     }
  1192.     return ((instancemethodobject *)im)->im_class;
  1193. }
  1194.  
  1195. /* Class method methods */
  1196.  
  1197. #define OFF(x) offsetof(instancemethodobject, x)
  1198.  
  1199. static struct memberlist instancemethod_memberlist[] = {
  1200.     {"im_func",    T_OBJECT,    OFF(im_func)},
  1201.     {"im_self",    T_OBJECT,    OFF(im_self)},
  1202.     {"im_class",    T_OBJECT,    OFF(im_class)},
  1203.     {"im_doc",    T_OBJECT,    OFF(im_doc)},
  1204.     {"__doc__",    T_OBJECT,    OFF(im_doc)},
  1205.     {NULL}    /* Sentinel */
  1206. };
  1207.  
  1208. static object *
  1209. instancemethod_getattr(im, name)
  1210.     register instancemethodobject *im;
  1211.     char *name;
  1212. {
  1213.     if (name[0] != '_' && getrestricted()) {
  1214.         err_setstr(RuntimeError,
  1215.                "instance-method attributes not accessible in restricted mode");
  1216.         return NULL;
  1217.     }
  1218.     return getmember((char *)im, instancemethod_memberlist, name);
  1219. }
  1220.  
  1221. static void
  1222. instancemethod_dealloc(im)
  1223.     register instancemethodobject *im;
  1224. {
  1225.     DECREF(im->im_func);
  1226.     XDECREF(im->im_self);
  1227.     DECREF(im->im_class);
  1228.     XDECREF(im->im_doc);
  1229.     free((ANY *)im);
  1230. }
  1231.  
  1232. static int
  1233. instancemethod_compare(a, b)
  1234.     instancemethodobject *a, *b;
  1235. {
  1236.     if (a->im_self != b->im_self)
  1237.         return (a->im_self < b->im_self) ? -1 : 1;
  1238.     return cmpobject(a->im_func, b->im_func);
  1239. }
  1240.  
  1241. static object *
  1242. instancemethod_repr(a)
  1243.     instancemethodobject *a;
  1244. {
  1245.     char buf[240];
  1246.     instanceobject *self = (instanceobject *)(a->im_self);
  1247.     funcobject *func = (funcobject *)(a->im_func);
  1248.     classobject *class = (classobject *)(a->im_class);
  1249.     object *fclassname, *iclassname, *funcname;
  1250.     char *fcname, *icname, *fname;
  1251.     fclassname = class->cl_name;
  1252.     funcname = func->func_name;
  1253.     if (fclassname != NULL && is_stringobject(fclassname))
  1254.         fcname = getstringvalue(fclassname);
  1255.     else
  1256.         fcname = "?";
  1257.     if (funcname != NULL && is_stringobject(funcname))
  1258.         fname = getstringvalue(funcname);
  1259.     else
  1260.         fname = "?";
  1261.     if (self == NULL)
  1262.         sprintf(buf, "<unbound method %.100s.%.100s>", fcname, fname);
  1263.     else {
  1264.         iclassname = self->in_class->cl_name;
  1265.         if (iclassname != NULL && is_stringobject(iclassname))
  1266.             icname = getstringvalue(iclassname);
  1267.         else
  1268.             icname = "?";
  1269.         sprintf(buf, "<method %.60s.%.60s of %.60s instance at %lx>",
  1270.             fcname, fname, icname, (long)self);
  1271.     }
  1272.     return newstringobject(buf);
  1273. }
  1274.  
  1275. static long
  1276. instancemethod_hash(a)
  1277.     instancemethodobject *a;
  1278. {
  1279.     long x, y;
  1280.     if (a->im_self == NULL)
  1281.         x = hashobject(None);
  1282.     else
  1283.         x = hashobject(a->im_self);
  1284.     if (x == -1)
  1285.         return -1;
  1286.     y = hashobject(a->im_func);
  1287.     if (y == -1)
  1288.         return -1;
  1289.     return x ^ y;
  1290. }
  1291.  
  1292. typeobject Instancemethodtype = {
  1293.     OB_HEAD_INIT(&Typetype)
  1294.     0,
  1295.     "instance method",
  1296.     sizeof(instancemethodobject),
  1297.     0,
  1298.     (destructor)instancemethod_dealloc, /*tp_dealloc*/
  1299.     0,            /*tp_print*/
  1300.     (getattrfunc)instancemethod_getattr, /*tp_getattr*/
  1301.     0,            /*tp_setattr*/
  1302.     (cmpfunc)instancemethod_compare, /*tp_compare*/
  1303.     (reprfunc)instancemethod_repr, /*tp_repr*/
  1304.     0,            /*tp_as_number*/
  1305.     0,            /*tp_as_sequence*/
  1306.     0,            /*tp_as_mapping*/
  1307.     (hashfunc)instancemethod_hash, /*tp_hash*/
  1308. };
  1309.